/*
题目描述
一条咸鱼想去图书馆学习，然而在去图书馆的路上有许多的吃货，他们今晚都想吃咸鱼干。咸鱼沉迷学习不能自拔，它必须设法绕过所有的吃货。

输入
第一行是两个正整数n, m（2 <= n, m <= 100)，表示矩形地图的大小。
第二行是一个正整数a (0 <= a <= 100)，表示有a个吃货。
接下来a行，每行有两个自然数xi, yi表示第i个吃货的位置。点(xi,
yi)可能不在地图之内。 咸鱼的起始位置是(0, 0)，图书馆的位置是(n-1,
m-1)，判断咸鱼今晚是否能学习。

输出
若咸鱼能学习，则输出Yes，否则输出No。

样例输入
3 3
2
1 1
0 2
样例输出
Yes

样例输入
3 3
2
1 2
2 1
样例输出
No
*/

/* 分析：迷宫问题
 * 1- 没有二极管通道的迷宫，若某解路径不是简单曲线而和自身相交，
 *    则可以在其上截取处简单曲线。
 *    因此若某路径不得不经过已经走过的空间，则其可以舍弃
 * 2- 若现在走过的路径不是解路径，这是因为之前有至少一步走错了
 */

#include <stdio.h>
#include <stdlib.h>

enum ROADSTAT
{
    OK,
    WALL,
    PASSED
};

struct map_t
{
    int *startpoint;
    int xlen;
    int ylen;
} map;

typedef struct position_t
{
    int x;
    int y;
} pos_t;

struct
{
    pos_t *pos;
    pos_t *stack;
    pos_t *stack_ptr;
} fish;

void init();
void fish_go();
void fish_successful_step(pos_t pos);
void map_setpoint(struct position_t pos, int val)
{
    map.startpoint[pos.x + map.xlen * pos.y] = val;
}

int is_pos_accessible(pos_t pos)
{
    if (pos.x < 0 || pos.x >= map.xlen)
        return 0;
    if (pos.y < 0 || pos.y >= map.ylen)
        return 0;
    return !(map.startpoint[pos.x + map.xlen * pos.y]);
}

int main()
{
    init();
    while(fish.pos->x != map.xlen-1 || fish.pos->y != map.ylen-1)
    {
        fish_go();
        if(fish.pos == fish.stack){
            printf("No\n");
            goto END;
        }
    }

    printf("Yes\n");


END:
    free(fish.stack);
    fish.stack = NULL;
    fish.stack_ptr = NULL;
    free(map.startpoint);
    map.startpoint = NULL;
}

void init()
{
    scanf("%d%d", &map.xlen, &map.ylen);
    map.startpoint = (int *)malloc(sizeof(int) * map.xlen * map.ylen);
    for (int i = 0; i < map.xlen * map.ylen; i++)
    {
        *map.startpoint = OK;
    }

    int num_of_wall;
    scanf("%d", &num_of_wall);
    fish.stack = (pos_t *)malloc(sizeof(pos_t) * (map.xlen * map.ylen - num_of_wall));
    fish.stack->x = 0;
    fish.stack->y = 0;
    fish.pos = fish.stack + 1;
    fish.pos->x = 0;
    fish.pos->y = 0;
    map_setpoint(*fish.pos, PASSED);

    pos_t tmppos;
    for (int i = 0; i < num_of_wall; i++)
    {
        scanf("%d%d", &tmppos.x, &tmppos.y);
        map_setpoint(tmppos, WALL);
    }
}

void fish_go()
{
    pos_t next_pos;
    next_pos.x = fish.pos->x + 1;
    next_pos.y = fish.pos->y;
    if (is_pos_accessible(next_pos))
    {
        if (next_pos.x != (fish.pos - 1)->x || next_pos.y != (fish.pos - 1)->y)
            fish_successful_step(next_pos);
        return;
    }
    next_pos.x = fish.pos->x;
    next_pos.y = fish.pos->y + 1;
    if (is_pos_accessible(next_pos))
    {
        if (next_pos.x != (fish.pos - 1)->x || next_pos.y != (fish.pos - 1)->y)
            fish_successful_step(next_pos);
        return;
    }
    next_pos.x = fish.pos->x;
    next_pos.y = fish.pos->y - 1;
    if (is_pos_accessible(next_pos))
    {
        if (next_pos.x != (fish.pos - 1)->x || next_pos.y != (fish.pos - 1)->y)
            fish_successful_step(next_pos);
        return;
    }
    next_pos.x = fish.pos->x - 1;
    next_pos.y = fish.pos->y;
    if (is_pos_accessible(next_pos))
    {
        if (next_pos.x != (fish.pos - 1)->x || next_pos.y != (fish.pos - 1)->y)
            fish_successful_step(next_pos);
        return;
    }
    
    map_setpoint(*fish.pos,WALL);
    fish.pos--;
}

void fish_successful_step(pos_t pos)
{
    fish.pos++;
    *fish.pos = pos;
    map_setpoint(*fish.pos, PASSED);
}
